+Sat Nov 28 00:06:49 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c: deprecated gtk_widget_freeze_accelerators and
+ gtk_widget_thaw_accelerators, we provide gtk_widget_lock_accelerators
+ and gtk_widget_unlock_accelerators.
+
+ * gtk/gtklayout.h:
+ * gtk/gtklayout.c: implemented incremental freezing facility.
+
+ * gtk/gtktext.h:
+ * gtk/gtktext.c: implemented incremental freezing facility.
+
+ * gtk/gtkenums.h:
+ * gtk/gtkaccelgroup.h: moved enum GtkAccelFlags into this place.
+
+ * gtk/gtkentry.h:
+ * gtk/gtkentry.c:
+ deprecated gtk_entry_adjust_scroll().
+
+ * random GtkType, macro and indentation fixes.
+
+Fri Nov 27 22:50:15 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkclist.h:
+ * gtk/gtkclist.c: implemented incremental freezing facility, added
+ a new class member (*refresh)() which takes over the thaw
+ functionality. the clist FROZEN flag got removed on the way.
+ * gtk/gtkctree.c: adaptions to feature the clist refresh functionality
+ and incremental freezing.
+
+ * gtk/gtkcalendar.c: implemented incremental freezing facility.
+
Fri Nov 27 11:41:27 1998 Raph Levien <raph@gimp.org>
* gdk/gdkinputcommon.h (gdk_input_common_init): Fixed it so that
+Sat Nov 28 00:06:49 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c: deprecated gtk_widget_freeze_accelerators and
+ gtk_widget_thaw_accelerators, we provide gtk_widget_lock_accelerators
+ and gtk_widget_unlock_accelerators.
+
+ * gtk/gtklayout.h:
+ * gtk/gtklayout.c: implemented incremental freezing facility.
+
+ * gtk/gtktext.h:
+ * gtk/gtktext.c: implemented incremental freezing facility.
+
+ * gtk/gtkenums.h:
+ * gtk/gtkaccelgroup.h: moved enum GtkAccelFlags into this place.
+
+ * gtk/gtkentry.h:
+ * gtk/gtkentry.c:
+ deprecated gtk_entry_adjust_scroll().
+
+ * random GtkType, macro and indentation fixes.
+
+Fri Nov 27 22:50:15 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkclist.h:
+ * gtk/gtkclist.c: implemented incremental freezing facility, added
+ a new class member (*refresh)() which takes over the thaw
+ functionality. the clist FROZEN flag got removed on the way.
+ * gtk/gtkctree.c: adaptions to feature the clist refresh functionality
+ and incremental freezing.
+
+ * gtk/gtkcalendar.c: implemented incremental freezing facility.
+
Fri Nov 27 11:41:27 1998 Raph Levien <raph@gimp.org>
* gdk/gdkinputcommon.h (gdk_input_common_init): Fixed it so that
+Sat Nov 28 00:06:49 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c: deprecated gtk_widget_freeze_accelerators and
+ gtk_widget_thaw_accelerators, we provide gtk_widget_lock_accelerators
+ and gtk_widget_unlock_accelerators.
+
+ * gtk/gtklayout.h:
+ * gtk/gtklayout.c: implemented incremental freezing facility.
+
+ * gtk/gtktext.h:
+ * gtk/gtktext.c: implemented incremental freezing facility.
+
+ * gtk/gtkenums.h:
+ * gtk/gtkaccelgroup.h: moved enum GtkAccelFlags into this place.
+
+ * gtk/gtkentry.h:
+ * gtk/gtkentry.c:
+ deprecated gtk_entry_adjust_scroll().
+
+ * random GtkType, macro and indentation fixes.
+
+Fri Nov 27 22:50:15 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkclist.h:
+ * gtk/gtkclist.c: implemented incremental freezing facility, added
+ a new class member (*refresh)() which takes over the thaw
+ functionality. the clist FROZEN flag got removed on the way.
+ * gtk/gtkctree.c: adaptions to feature the clist refresh functionality
+ and incremental freezing.
+
+ * gtk/gtkcalendar.c: implemented incremental freezing facility.
+
Fri Nov 27 11:41:27 1998 Raph Levien <raph@gimp.org>
* gdk/gdkinputcommon.h (gdk_input_common_init): Fixed it so that
+Sat Nov 28 00:06:49 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c: deprecated gtk_widget_freeze_accelerators and
+ gtk_widget_thaw_accelerators, we provide gtk_widget_lock_accelerators
+ and gtk_widget_unlock_accelerators.
+
+ * gtk/gtklayout.h:
+ * gtk/gtklayout.c: implemented incremental freezing facility.
+
+ * gtk/gtktext.h:
+ * gtk/gtktext.c: implemented incremental freezing facility.
+
+ * gtk/gtkenums.h:
+ * gtk/gtkaccelgroup.h: moved enum GtkAccelFlags into this place.
+
+ * gtk/gtkentry.h:
+ * gtk/gtkentry.c:
+ deprecated gtk_entry_adjust_scroll().
+
+ * random GtkType, macro and indentation fixes.
+
+Fri Nov 27 22:50:15 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkclist.h:
+ * gtk/gtkclist.c: implemented incremental freezing facility, added
+ a new class member (*refresh)() which takes over the thaw
+ functionality. the clist FROZEN flag got removed on the way.
+ * gtk/gtkctree.c: adaptions to feature the clist refresh functionality
+ and incremental freezing.
+
+ * gtk/gtkcalendar.c: implemented incremental freezing facility.
+
Fri Nov 27 11:41:27 1998 Raph Levien <raph@gimp.org>
* gdk/gdkinputcommon.h (gdk_input_common_init): Fixed it so that
+Sat Nov 28 00:06:49 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c: deprecated gtk_widget_freeze_accelerators and
+ gtk_widget_thaw_accelerators, we provide gtk_widget_lock_accelerators
+ and gtk_widget_unlock_accelerators.
+
+ * gtk/gtklayout.h:
+ * gtk/gtklayout.c: implemented incremental freezing facility.
+
+ * gtk/gtktext.h:
+ * gtk/gtktext.c: implemented incremental freezing facility.
+
+ * gtk/gtkenums.h:
+ * gtk/gtkaccelgroup.h: moved enum GtkAccelFlags into this place.
+
+ * gtk/gtkentry.h:
+ * gtk/gtkentry.c:
+ deprecated gtk_entry_adjust_scroll().
+
+ * random GtkType, macro and indentation fixes.
+
+Fri Nov 27 22:50:15 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkclist.h:
+ * gtk/gtkclist.c: implemented incremental freezing facility, added
+ a new class member (*refresh)() which takes over the thaw
+ functionality. the clist FROZEN flag got removed on the way.
+ * gtk/gtkctree.c: adaptions to feature the clist refresh functionality
+ and incremental freezing.
+
+ * gtk/gtkcalendar.c: implemented incremental freezing facility.
+
Fri Nov 27 11:41:27 1998 Raph Levien <raph@gimp.org>
* gdk/gdkinputcommon.h (gdk_input_common_init): Fixed it so that
+Sat Nov 28 00:06:49 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c: deprecated gtk_widget_freeze_accelerators and
+ gtk_widget_thaw_accelerators, we provide gtk_widget_lock_accelerators
+ and gtk_widget_unlock_accelerators.
+
+ * gtk/gtklayout.h:
+ * gtk/gtklayout.c: implemented incremental freezing facility.
+
+ * gtk/gtktext.h:
+ * gtk/gtktext.c: implemented incremental freezing facility.
+
+ * gtk/gtkenums.h:
+ * gtk/gtkaccelgroup.h: moved enum GtkAccelFlags into this place.
+
+ * gtk/gtkentry.h:
+ * gtk/gtkentry.c:
+ deprecated gtk_entry_adjust_scroll().
+
+ * random GtkType, macro and indentation fixes.
+
+Fri Nov 27 22:50:15 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkclist.h:
+ * gtk/gtkclist.c: implemented incremental freezing facility, added
+ a new class member (*refresh)() which takes over the thaw
+ functionality. the clist FROZEN flag got removed on the way.
+ * gtk/gtkctree.c: adaptions to feature the clist refresh functionality
+ and incremental freezing.
+
+ * gtk/gtkcalendar.c: implemented incremental freezing facility.
+
Fri Nov 27 11:41:27 1998 Raph Levien <raph@gimp.org>
* gdk/gdkinputcommon.h (gdk_input_common_init): Fixed it so that
+Sat Nov 28 00:06:49 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c: deprecated gtk_widget_freeze_accelerators and
+ gtk_widget_thaw_accelerators, we provide gtk_widget_lock_accelerators
+ and gtk_widget_unlock_accelerators.
+
+ * gtk/gtklayout.h:
+ * gtk/gtklayout.c: implemented incremental freezing facility.
+
+ * gtk/gtktext.h:
+ * gtk/gtktext.c: implemented incremental freezing facility.
+
+ * gtk/gtkenums.h:
+ * gtk/gtkaccelgroup.h: moved enum GtkAccelFlags into this place.
+
+ * gtk/gtkentry.h:
+ * gtk/gtkentry.c:
+ deprecated gtk_entry_adjust_scroll().
+
+ * random GtkType, macro and indentation fixes.
+
+Fri Nov 27 22:50:15 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkclist.h:
+ * gtk/gtkclist.c: implemented incremental freezing facility, added
+ a new class member (*refresh)() which takes over the thaw
+ functionality. the clist FROZEN flag got removed on the way.
+ * gtk/gtkctree.c: adaptions to feature the clist refresh functionality
+ and incremental freezing.
+
+ * gtk/gtkcalendar.c: implemented incremental freezing facility.
+
Fri Nov 27 11:41:27 1998 Raph Levien <raph@gimp.org>
* gdk/gdkinputcommon.h (gdk_input_common_init): Fixed it so that
typedef struct _GtkAccelGroup GtkAccelGroup;
typedef struct _GtkAccelEntry GtkAccelEntry;
-/* enum GtkAccelFlags:
- *
- * GTK_ACCEL_VISIBLE - should the accelerator appear in
- * the widget's display?
- * GTK_ACCEL_SIGNAL_VISIBLE - should the signal associated
- * with this accelerator be also visible?
- * GTK_ACCEL_LOCKED - may the accelerator be removed again?
- */
+typedef enum
+{
+ /* should the accelerator appear in
+ * the widget's display?
+ */
+ GTK_ACCEL_VISIBLE = 1 << 0,
+ /* should the signal associated with
+ * this accelerator be also visible?
+ */
+ GTK_ACCEL_SIGNAL_VISIBLE = 1 << 1,
+ /* may the accelerator be removed
+ * again?
+ */
+ GTK_ACCEL_LOCKED = 1 << 2,
+ GTK_ACCEL_MASK = 0x07
+} GtkAccelFlags;
struct _GtkAccelGroup
{
GdkWindow *week_win;
GdkWindow *arrow_win[4];
- guint header_h, day_name_h, main_h;
+ guint header_h;
+ guint day_name_h;
+ guint main_h;
guint arrow_state[4];
guint arrow_width;
guint max_label_char_descent;
guint max_week_char_width;
+ guint freeze_count;
+
/* flags */
- unsigned int dirty_header:1;
- unsigned int dirty_day_names:1;
- unsigned int dirty_main:1;
- unsigned int dirty_week:1;
- unsigned int frozen;
+ guint dirty_header : 1;
+ guint dirty_day_names : 1;
+ guint dirty_main : 1;
+ guint dirty_week : 1;
};
#define GTK_CALENDAR_PRIVATE_DATA(widget) (((GtkCalendarPrivateData*)(GTK_CALENDAR (widget)->private_data)))
private_data->max_label_char_descent = 0;
private_data->arrow_width = 10;
+
+ private_data->freeze_count = 0;
private_data->dirty_header = 0;
private_data->dirty_day_names = 0;
private_data->dirty_week = 0;
private_data->dirty_main = 0;
- private_data->frozen = 0;
}
GtkWidget*
calendar = GTK_CALENDAR (widget);
private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
- if (private_data->frozen)
+ if (private_data->freeze_count)
{
private_data->dirty_header = 1;
return;
* Handle freeze/thaw functionality
*/
- if (private_data->frozen)
+ if (private_data->freeze_count)
{
private_data->dirty_day_names = 1;
return;
* Handle freeze/thaw functionality
*/
- if (private_data->frozen)
+ if (private_data->freeze_count)
{
private_data->dirty_week = 1;
return;
* Handle freeze/thaw functionality
*/
- if (private_data->frozen)
+ if (private_data->freeze_count)
{
private_data->dirty_main = 1;
return;
calendar = GTK_CALENDAR (widget);
private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
- if (private_data->frozen)
+ if (private_data->freeze_count)
{
private_data->dirty_main = 1;
return;
calendar = GTK_CALENDAR (widget);
private_data = GTK_CALENDAR_PRIVATE_DATA (widget);
- if (private_data->frozen)
+ if (private_data->freeze_count)
{
private_data->dirty_header = 1;
return;
g_return_if_fail (calendar != NULL);
g_return_if_fail (GTK_IS_CALENDAR (calendar));
- GTK_CALENDAR_PRIVATE_DATA (calendar)->frozen++;
+ GTK_CALENDAR_PRIVATE_DATA (calendar)->freeze_count++;
}
void
g_return_if_fail (GTK_IS_CALENDAR (calendar));
private_data = GTK_CALENDAR_PRIVATE_DATA (calendar);
-
- if (private_data->frozen)
- {
- private_data->frozen--;
- if (private_data->frozen)
- return;
-
- if (private_data->dirty_header)
- if (GTK_WIDGET_DRAWABLE (calendar))
- gtk_calendar_paint_header (GTK_WIDGET (calendar));
-
- if (private_data->dirty_day_names)
- if (GTK_WIDGET_DRAWABLE (calendar))
- gtk_calendar_paint_day_names (GTK_WIDGET (calendar));
-
- if (private_data->dirty_week)
- if (GTK_WIDGET_DRAWABLE (calendar))
- gtk_calendar_paint_week_numbers (GTK_WIDGET (calendar));
-
- if (private_data->dirty_main)
- if (GTK_WIDGET_DRAWABLE (calendar))
- gtk_calendar_paint_main (GTK_WIDGET (calendar));
- }
+
+ if (private_data->freeze_count)
+ if (!(--private_data->freeze_count))
+ {
+ if (private_data->dirty_header)
+ if (GTK_WIDGET_DRAWABLE (calendar))
+ gtk_calendar_paint_header (GTK_WIDGET (calendar));
+
+ if (private_data->dirty_day_names)
+ if (GTK_WIDGET_DRAWABLE (calendar))
+ gtk_calendar_paint_day_names (GTK_WIDGET (calendar));
+
+ if (private_data->dirty_week)
+ if (GTK_WIDGET_DRAWABLE (calendar))
+ gtk_calendar_paint_week_numbers (GTK_WIDGET (calendar));
+
+ if (private_data->dirty_main)
+ if (GTK_WIDGET_DRAWABLE (calendar))
+ gtk_calendar_paint_main (GTK_WIDGET (calendar));
+ }
}
static void
gint highlight_col;
gpointer private_data;
- char grow_space [32];
+ gchar grow_space [32];
};
struct _GtkCalendarClass
return 0;
}
-#define GTK_CLIST_CLASS_FW(_widget_) GTK_CLIST_CLASS (GTK_OBJECT (_widget_)->klass)
+#define GTK_CLIST_CLASS_FW(_widget_) GTK_CLIST_CLASS (((GtkObject*) (_widget_))->klass)
+
+/* redraw the list if it's not frozen */
+#define CLIST_UNFROZEN(clist) (((GtkCList*) (clist))->freeze_count == 0)
+#define CLIST_REFRESH(clist) G_STMT_START { \
+ if (CLIST_UNFROZEN (clist)) \
+ GTK_CLIST_CLASS_FW (clist)->refresh ((GtkCList*) (clist)); \
+} G_STMT_END
/* Signals */
GtkCListRow *clist_row);
static void draw_rows (GtkCList *clist,
GdkRectangle *area);
-
+static void clist_refresh (GtkCList *clist);
+
/* Size Allocation / Requisition */
static void size_allocate_title_buttons (GtkCList *clist);
static void size_allocate_columns (GtkCList *clist,
container_class->set_focus_child = gtk_clist_set_focus_child;
klass->scroll_adjustments = gtk_clist_scroll_adjustments;
+ klass->refresh = clist_refresh;
klass->select_row = real_select_row;
klass->unselect_row = real_unselect_row;
klass->undo_selection = real_undo_selection;
clist->flags = 0;
GTK_WIDGET_UNSET_FLAGS (clist, GTK_NO_WINDOW);
- GTK_CLIST_SET_FLAG (clist, CLIST_FROZEN);
clist->row_mem_chunk = NULL;
clist->cell_mem_chunk = NULL;
+ clist->freeze_count = 0;
+
clist->rows = 0;
clist->row_center_offset = 0;
clist->row_height = 0;
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
- GTK_CLIST_SET_FLAG (clist, CLIST_FROZEN);
+ clist->freeze_count++;
}
void
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
- GTK_CLIST_UNSET_FLAG (clist, CLIST_FROZEN);
- adjust_adjustments (clist, FALSE);
- draw_rows (clist, NULL);
+ if (clist->freeze_count)
+ {
+ clist->freeze_count--;
+ CLIST_REFRESH (clist);
+ }
}
/* PUBLIC COLUMN FUNCTIONS
}
}
- if (!GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist))
draw_rows (clist, NULL);
}
size_allocate_columns (clist, TRUE);
size_allocate_title_buttons (clist);
- if (!GTK_CLIST_FROZEN (clist))
- {
- adjust_adjustments (clist, FALSE);
- draw_rows (clist, NULL);
- }
+ CLIST_REFRESH (clist);
}
static void
widget->style->font->descent - 1) / 2;
}
- if (!GTK_CLIST_FROZEN (clist))
- {
- adjust_adjustments (clist, FALSE);
- draw_rows (clist, NULL);
- }
+ CLIST_REFRESH (clist);
}
void
(clist, clist_row, column, GTK_CELL_TEXT, text, 0, NULL, NULL);
/* redraw the list if it's not frozen */
- if (!GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist))
{
if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
(clist, clist_row, column, GTK_CELL_PIXMAP, NULL, 0, pixmap, mask);
/* redraw the list if it's not frozen */
- if (!GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist))
{
if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
(clist, clist_row, column, GTK_CELL_PIXTEXT, text, spacing, pixmap, mask);
/* redraw the list if it's not frozen */
- if (!GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist))
{
if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
column_auto_resize (clist, clist_row, column, requisition.width);
- if (!GTK_CLIST_FROZEN (clist)
- && (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE))
+ if (CLIST_UNFROZEN (clist) && gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
}
sync_selection (clist, row, SYNC_INSERT);
/* redraw the list if it isn't frozen */
- if (!GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist))
{
adjust_adjustments (clist, FALSE);
row_delete (clist, clist_row);
/* redraw the row if it isn't frozen */
- if (!GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist))
{
adjust_adjustments (clist, FALSE);
if (clist->vadjustment)
{
gtk_adjustment_set_value (clist->vadjustment, 0.0);
- if (!GTK_CLIST_FROZEN (clist))
- gtk_clist_thaw (clist);
+ CLIST_REFRESH (clist);
}
else
gtk_widget_queue_resize (GTK_WIDGET (clist));
list = list->next;
}
- if (!GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist))
{
if (gtk_clist_row_is_visible (clist, last) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row
- (clist, NULL, last, GTK_CLIST_ROW (link2));
+ GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, last, GTK_CLIST_ROW (link2));
if (gtk_clist_row_is_visible (clist, first) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row
- (clist, NULL, first, GTK_CLIST_ROW (link1));
+ GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, first, GTK_CLIST_ROW (link1));
}
}
else
clist_row->fg_set = FALSE;
- if (!GTK_CLIST_FROZEN (clist)
- && (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE))
+ if (CLIST_UNFROZEN (clist) && gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
}
else
clist_row->bg_set = FALSE;
- if (!GTK_CLIST_FROZEN (clist)
+ if (CLIST_UNFROZEN (clist)
&& (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE))
GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
}
column_auto_resize (clist, clist_row, column, requisition.width);
/* redraw the list if it's not frozen */
- if (!GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist))
{
if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
g_free (old_width);
/* redraw the list if it's not frozen */
- if (!GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist))
{
if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
else
clist->anchor_state = GTK_CLIST_ROW (work)->state = GTK_STATE_NORMAL;
- if (!GTK_CLIST_FROZEN (clist) &&
+ if (CLIST_UNFROZEN (clist) &&
gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row,
GTK_CLIST_ROW (work));
clist->selection_end =
g_list_append (clist->selection_end, GINT_TO_POINTER (row))->next;
- if (!GTK_CLIST_FROZEN (clist)
+ if (CLIST_UNFROZEN (clist)
&& (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE))
GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
}
clist->selection = g_list_remove (clist->selection,
GINT_TO_POINTER (row));
- if (!GTK_CLIST_FROZEN (clist)
+ if (CLIST_UNFROZEN (clist)
&& (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE))
GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
}
{
GTK_CLIST_ROW (work)->state = GTK_STATE_SELECTED;
- if (!GTK_CLIST_FROZEN (clist) &&
+ if (CLIST_UNFROZEN (clist) &&
gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row,
GTK_CLIST_ROW (work));
continue;
GTK_CLIST_ROW (work)->state = GTK_STATE_NORMAL;
- if (!GTK_CLIST_FROZEN (clist) &&
+ if (CLIST_UNFROZEN (clist) &&
gtk_clist_row_is_visible (clist, i) != GTK_VISIBILITY_NONE)
GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, i,
GTK_CLIST_ROW (work));
gint i;
gint e;
gint row;
- gboolean thaw = FALSE;
GList *list;
GtkCListRow *clist_row;
if (clist->anchor < 0)
return;
- if (!GTK_CLIST_FROZEN (clist))
- {
- GTK_CLIST_SET_FLAG (clist, CLIST_FROZEN);
- thaw = TRUE;
- }
+ gtk_clist_freeze (clist);
i = MIN (clist->anchor, clist->drag_pos);
e = MAX (clist->anchor, clist->drag_pos);
clist->anchor = -1;
clist->drag_pos = -1;
- if (thaw)
- GTK_CLIST_UNSET_FLAG (clist, CLIST_FROZEN);
+ gtk_clist_thaw (clist);
}
static void
clist = GTK_CLIST (object);
/* freeze the list */
- GTK_CLIST_SET_FLAG (clist, CLIST_FROZEN);
+ clist->freeze_count++;
/* get rid of all the rows */
gtk_clist_clear (clist);
clist = GTK_CLIST (widget);
- GTK_CLIST_SET_FLAG (clist, CLIST_FROZEN);
+ /* freeze the list */
+ clist->freeze_count++;
/* detach optional row/cell styles */
gdk_window_show (clist->column[i].window);
/* unfreeze the list */
- GTK_CLIST_UNSET_FLAG (clist, CLIST_FROZEN);
+ clist->freeze_count = 0;
}
}
gtk_widget_unmap (clist->column[i].button);
/* freeze the list */
- GTK_CLIST_SET_FLAG (clist, CLIST_FROZEN);
+ clist->freeze_count++;
}
}
* draw_row
* draw_rows
* draw_xor_line
+ * clist_refresh
*/
static void
get_cell_style (GtkCList *clist,
clist->clist_window_height + 1);
}
+static void
+clist_refresh (GtkCList *clist)
+{
+ g_return_if_fail (clist != NULL);
+ g_return_if_fail (GTK_IS_CLIST (clist));
+
+ if (CLIST_UNFROZEN (clist))
+ {
+ adjust_adjustments (clist, FALSE);
+ draw_rows (clist, NULL);
+ }
+}
+
/* get cell from coordinates
* get_selection_info
* gtk_clist_get_selection_info
GList *list;
GList *work;
gint i;
- gboolean thaw = FALSE;
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
return;
+ gtk_clist_freeze (clist);
+
if (clist->anchor != -1 && clist->selection_mode == GTK_SELECTION_EXTENDED)
{
GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
clist->undo_unselection = NULL;
}
- if (!GTK_CLIST_FROZEN (clist))
- {
- gtk_clist_freeze (clist);
- thaw = TRUE;
- }
-
clist->row_list = gtk_clist_mergesort (clist, clist->row_list, clist->rows);
work = clist->selection;
clist->row_list_end = list;
}
- if (thaw)
- gtk_clist_thaw (clist);
+ gtk_clist_thaw (clist);
}
static GList *
/* clist flags */
enum
{
- GTK_CLIST_FROZEN = 1 << 0,
- GTK_CLIST_IN_DRAG = 1 << 1,
- GTK_CLIST_DRAG_SELECTION = 1 << 2,
- GTK_CLIST_ROW_HEIGHT_SET = 1 << 3,
- GTK_CLIST_SHOW_TITLES = 1 << 4,
- GTK_CLIST_CHILD_HAS_FOCUS = 1 << 5,
- GTK_CLIST_ADD_MODE = 1 << 6,
- GTK_CLIST_AUTO_SORT = 1 << 7,
- GTK_CLIST_AUTO_RESIZE_BLOCKED = 1 << 8
+ GTK_CLIST_IN_DRAG = 1 << 0,
+ GTK_CLIST_DRAG_SELECTION = 1 << 1,
+ GTK_CLIST_ROW_HEIGHT_SET = 1 << 2,
+ GTK_CLIST_SHOW_TITLES = 1 << 3,
+ GTK_CLIST_CHILD_HAS_FOCUS = 1 << 4,
+ GTK_CLIST_ADD_MODE = 1 << 5,
+ GTK_CLIST_AUTO_SORT = 1 << 6,
+ GTK_CLIST_AUTO_RESIZE_BLOCKED = 1 << 7
};
/* cell types */
#define GTK_CLIST_SET_FLAG(clist,flag) (GTK_CLIST_FLAGS (clist) |= (GTK_ ## flag))
#define GTK_CLIST_UNSET_FLAG(clist,flag) (GTK_CLIST_FLAGS (clist) &= ~(GTK_ ## flag))
-#define GTK_CLIST_FROZEN(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_FROZEN)
#define GTK_CLIST_IN_DRAG(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_IN_DRAG)
#define GTK_CLIST_ROW_HEIGHT_SET(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_ROW_HEIGHT_SET)
#define GTK_CLIST_SHOW_TITLES(clist) (GTK_CLIST_FLAGS (clist) & GTK_CLIST_SHOW_TITLES)
/* mem chunks */
GMemChunk *row_mem_chunk;
GMemChunk *cell_mem_chunk;
+
+ guint freeze_count;
/* allocation rectangle after the conatiner_border_width
* and the width of the shadow border */
void (*scroll_adjustments) (GtkCList *clist,
GtkAdjustment *hadjustment,
GtkAdjustment *vadjustment);
+ void (*refresh) (GtkCList *clist);
void (*select_row) (GtkCList *clist,
gint row,
gint column,
+ (clist)->hoffset)
#define COLUMN_LEFT(clist, column) ((clist)->column[(column)].area.x)
-#define GTK_CLIST_CLASS_FW(_widget_) GTK_CLIST_CLASS (GTK_OBJECT (_widget_)->klass)
+#define GTK_CLIST_CLASS_FW(_widget_) GTK_CLIST_CLASS (((GtkObject*) (_widget_))->klass)
+#define CLIST_UNFROZEN(clist) (((GtkCList*) (clist))->freeze_count == 0)
+#define CLIST_REFRESH(clist) G_STMT_START { \
+ if (CLIST_UNFROZEN (clist)) \
+ GTK_CLIST_CLASS_FW (clist)->refresh ((GtkCList*) (clist)); \
+} G_STMT_END
+
enum {
ARG_0,
clist = GTK_CLIST (ctree);
- if (!GTK_CLIST_FROZEN (clist) && gtk_ctree_is_viewable (ctree, node))
+ if (CLIST_UNFROZEN (clist) && gtk_ctree_is_viewable (ctree, node))
{
GtkCTreeNode *work;
gint num = 0;
{
GtkCList *clist;
GtkCTreeNode *work;
- gboolean thaw = FALSE;
gboolean visible = FALSE;
g_return_if_fail (ctree != NULL);
new_sibling == GTK_CTREE_ROW (node)->sibling)
return;
- if (!GTK_CLIST_FROZEN (clist))
- {
- gtk_clist_freeze (clist);
- thaw = TRUE;
- }
+ gtk_clist_freeze (clist);
work = NULL;
if (gtk_ctree_is_viewable (ctree, node) ||
(clist, ctree->tree_column,
gtk_clist_optimal_column_width (clist, ctree->tree_column));
- if (thaw)
- gtk_clist_thaw (clist);
+ gtk_clist_thaw (clist);
}
static void
clist->focus_row += tmp + 1;
clist->rows += tmp + 1;
- if (!GTK_CLIST_FROZEN (ctree))
- gtk_clist_thaw (clist);
+ CLIST_REFRESH (clist);
}
}
else if (visible && clist->column[ctree->tree_column].auto_resize)
if (row < clist->focus_row)
clist->focus_row -= tmp;
clist->rows -= tmp;
- if (!GTK_CLIST_FROZEN (ctree))
- gtk_clist_thaw (clist);
+ CLIST_REFRESH (clist);
}
}
else if (visible && clist->column[ctree->tree_column].auto_resize &&
{
GtkCTree *ctree;
GtkCTreeNode *node;
- gboolean thaw = FALSE;
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
case GTK_SELECTION_EXTENDED:
- if (!GTK_CLIST_FROZEN (clist))
- {
- gtk_clist_freeze (clist);
- thaw = TRUE;
- }
+ gtk_clist_freeze (clist);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
node = GTK_CTREE_NODE_NEXT (node))
gtk_ctree_pre_recursive (ctree, node, select_row_recursive, NULL);
- if (thaw)
- gtk_clist_thaw (clist);
+ gtk_clist_thaw (clist);
break;
case GTK_SELECTION_MULTIPLE:
column_auto_resize (clist, &(new_row->row), i, 0);
}
- if (!GTK_CLIST_FROZEN (clist))
- gtk_clist_thaw (clist);
+ CLIST_REFRESH (clist);
return node;
}
GtkCTreeNode *child = NULL;
GtkCTreeNode *new_child;
GList *list;
- gboolean thaw;
GNode *work;
guint depth = 1;
list->data = row_new (ctree);
cnode = GTK_CTREE_NODE (list);
- thaw = !GTK_CLIST_FROZEN (clist);
- if (thaw)
- gtk_clist_freeze (clist);
+ gtk_clist_freeze (clist);
set_node_info (ctree, cnode, "", 0, NULL, NULL, NULL, NULL, TRUE, FALSE);
child = new_child;
}
- if (thaw)
- gtk_clist_thaw (clist);
+ gtk_clist_thaw (clist);
return cnode;
}
GtkCTreeNode *node)
{
GtkCList *clist;
- gboolean thaw = FALSE;
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
- if (!GTK_CLIST_FROZEN (clist))
- {
- gtk_clist_freeze (clist);
- thaw = TRUE;
- }
+ gtk_clist_freeze (clist);
if (node)
{
else
gtk_clist_clear (clist);
- if (thaw)
- gtk_clist_thaw (clist);
+ gtk_clist_thaw (clist);
}
static void
if (node && GTK_CTREE_ROW (node)->is_leaf)
return;
- if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
- !GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
if (node && GTK_CTREE_ROW (node)->is_leaf)
return;
- if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
- !GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
clist = GTK_CLIST (ctree);
- if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
- !GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
clist = GTK_CLIST (ctree);
- if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
- !GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
clist = GTK_CLIST (ctree);
- if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
- !GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
(!state && clist->selection_mode == GTK_SELECTION_BROWSE))
return;
- if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
- !GTK_CLIST_FROZEN (clist))
+ if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
gtk_clist_set_column_width
(clist, ctree->tree_column,
gtk_clist_optimal_column_width (clist, ctree->tree_column));
- else if (!GTK_CLIST_FROZEN (ctree))
- gtk_clist_thaw (GTK_CLIST (ctree));
+ else
+ CLIST_REFRESH (ctree);
}
void
gtk_clist_set_column_width (clist, ctree->tree_column,
clist->column[ctree->tree_column].width +
spacing - old_spacing);
- else if (!GTK_CLIST_FROZEN (ctree))
- gtk_clist_thaw (GTK_CLIST (ctree));
+ else
+ CLIST_REFRESH (ctree);
}
void
clist = GTK_CLIST (ctree);
ctree->show_stub = show_stub;
- if (!GTK_CLIST_FROZEN (clist) && clist->rows &&
+ if (CLIST_UNFROZEN (clist) && clist->rows &&
gtk_clist_row_is_visible (clist, 0) != GTK_VISIBILITY_NONE)
GTK_CLIST_CLASS_FW (clist)->draw_row
(clist, NULL, 0, GTK_CLIST_ROW (clist->row_list));
default:
return;
}
- if (!GTK_CLIST_FROZEN (ctree))
- gtk_clist_thaw (GTK_CLIST (ctree));
+ CLIST_REFRESH (ctree);
}
}
gtk_clist_set_column_width (clist, ctree->tree_column, new_width);
}
- if (!GTK_CLIST_FROZEN (ctree) && GTK_WIDGET_DRAWABLE (clist))
- gtk_clist_thaw (GTK_CLIST (ctree));
+ if (GTK_WIDGET_DRAWABLE (clist))
+ CLIST_REFRESH (clist);
}
{
GtkCList *clist;
GtkCTreeNode *focus_node = NULL;
- gboolean thaw = FALSE;
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
- if (!GTK_CLIST_FROZEN (clist))
- {
- gtk_clist_freeze (clist);
- thaw = TRUE;
- }
+ gtk_clist_freeze (clist);
if (clist->selection_mode == GTK_SELECTION_EXTENDED)
{
clist->undo_anchor = clist->focus_row;
}
- if (thaw)
- gtk_clist_thaw (clist);
+ gtk_clist_thaw (clist);
}
static void
{
GtkCList *clist;
GtkCTreeNode *focus_node = NULL;
- gboolean thaw = FALSE;
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
clist = GTK_CLIST (ctree);
- if (!GTK_CLIST_FROZEN (clist))
- {
- gtk_clist_freeze (clist);
- thaw = TRUE;
- }
+ gtk_clist_freeze (clist);
if (clist->selection_mode == GTK_SELECTION_EXTENDED)
{
clist->undo_anchor = clist->focus_row;
}
- if (thaw)
- gtk_clist_thaw (clist);
+ gtk_clist_thaw (clist);
}
/************************************************************************/
{
GTK_CTREE_ROW (focus_node)->row.state = GTK_STATE_SELECTED;
- if (!GTK_CLIST_FROZEN (clist) &&
+ if (CLIST_UNFROZEN (clist) &&
gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row,
GTK_CLIST_ROW (focus_node));
gint i;
gint e;
gint row;
- gboolean thaw = FALSE;
gboolean unselect;
g_return_if_fail (clist != NULL);
ctree = GTK_CTREE (clist);
- if (!GTK_CLIST_FROZEN (clist))
- {
- GTK_CLIST_SET_FLAG (clist, CLIST_FROZEN);
- thaw = TRUE;
- }
+ clist->freeze_count++;
i = MIN (clist->anchor, clist->drag_pos);
e = MAX (clist->anchor, clist->drag_pos);
clist->anchor = -1;
clist->drag_pos = -1;
- if (thaw)
- GTK_CLIST_UNSET_FLAG (clist, CLIST_FROZEN);
+ if (!CLIST_UNFROZEN (clist))
+ clist->freeze_count--;
}
static void
static gint gtk_entry_timer (gpointer data);
static gint gtk_entry_position (GtkEntry *entry,
gint x);
-/* static void gtk_entry_adjust_scroll (GtkEntry *entry); */
+static void entry_adjust_scroll (GtkEntry *entry);
static void gtk_entry_grow_text (GtkEntry *entry);
static void gtk_entry_insert_text (GtkEditable *editable,
const gchar *new_text,
editable_class->insert_text = gtk_entry_insert_text;
editable_class->delete_text = gtk_entry_delete_text;
- editable_class->changed = (void (*)(GtkEditable *)) gtk_entry_adjust_scroll;
+ editable_class->changed = (void (*)(GtkEditable *)) entry_adjust_scroll;
editable_class->move_cursor = gtk_entry_move_cursor;
editable_class->move_word = gtk_entry_move_word;
GTK_EDITABLE(entry)->current_pos = entry->text_length;
else
GTK_EDITABLE(entry)->current_pos = position;
- gtk_entry_adjust_scroll (entry);
+ entry_adjust_scroll (entry);
}
static void
widget->requisition.height - widget->style->klass->ythickness * 2);
/* And make sure the cursor is on screen */
- gtk_entry_adjust_scroll (entry);
+ entry_adjust_scroll (entry);
#ifdef USE_XIM
if (editable->ic && (gdk_ic_get_style (editable->ic) & GDK_IM_PREEDIT_POSITION))
GTK_EDITABLE(entry)->selection_end_pos = gtk_entry_position (entry, x + entry->scroll_offset);
GTK_EDITABLE(entry)->current_pos = GTK_EDITABLE(entry)->selection_end_pos;
- gtk_entry_adjust_scroll (entry);
+ entry_adjust_scroll (entry);
gtk_entry_queue_draw (entry);
return FALSE;
editable->selection_start_pos != editable->selection_end_pos,
event->time);
- gtk_entry_adjust_scroll (entry);
+ entry_adjust_scroll (entry);
gtk_entry_queue_draw (entry);
}
void
gtk_entry_adjust_scroll (GtkEntry *entry)
+{
+ g_return_if_fail (entry != NULL);
+ g_return_if_fail (GTK_IS_ENTRY (entry));
+
+ g_message ("gtk_entry_adjust_scroll() is deprecated");
+
+ entry_adjust_scroll (entry);
+}
+
+static void
+entry_adjust_scroll (GtkEntry *entry)
{
gint xoffset, max_offset;
gint text_area_width;
scroll_char = gtk_entry_find_position (entry, entry->scroll_offset);
gtk_entry_recompute_offsets (GTK_ENTRY (widget));
entry->scroll_offset = entry->char_offset[scroll_char];
- gtk_entry_adjust_scroll (entry);
+ entry_adjust_scroll (entry);
gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
gdk_window_set_background (entry->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
gboolean visible);
void gtk_entry_set_editable (GtkEntry *entry,
gboolean editable);
-/* DO NOT USE THIS FUNCTION. The only reason why it is public
- * is that there were bugs in GtkEntry. IT WILL DISAPPEAR. */
-void gtk_entry_adjust_scroll (GtkEntry *entry);
/* text is truncated if needed */
void gtk_entry_set_max_length (GtkEntry *entry,
guint16 max);
+/* deprecated function. The only reason why it is public
+ * is that there were bugs in GtkEntry. IT WILL DISAPPEAR.
+ */
+void gtk_entry_adjust_scroll (GtkEntry *entry);
#ifdef __cplusplus
}
extern "C" {
#endif /* __cplusplus */
-typedef enum
-{
- /* should the accelerator appear in
- * the widget's display?
- */
- GTK_ACCEL_VISIBLE = 1 << 0,
- /* should the signal associated with
- * this accelerator be also visible?
- */
- GTK_ACCEL_SIGNAL_VISIBLE = 1 << 1,
- /* may the accelerator be removed
- * again?
- */
- GTK_ACCEL_LOCKED = 1 << 2,
- GTK_ACCEL_MASK = 0x07
-} GtkAccelFlags;
-
/* Arrow types */
typedef enum
{
GdkEventExpose *event);
-guint
+GtkType
gtk_image_get_type (void)
{
- static guint image_type = 0;
+ static GtkType image_type = 0;
if (!image_type)
{
(GtkClassInitFunc) NULL,
};
- image_type = gtk_type_unique (gtk_misc_get_type (), &image_info);
+ image_type = gtk_type_unique (GTK_TYPE_MISC, &image_info);
}
return image_type;
g_return_val_if_fail (val != NULL, NULL);
- image = gtk_type_new (gtk_image_get_type ());
+ image = gtk_type_new (GTK_TYPE_IMAGE);
gtk_image_set (image, val, mask);
#endif /* __cplusplus */
-#define GTK_IMAGE(obj) GTK_CHECK_CAST (obj, gtk_image_get_type (), GtkImage)
-#define GTK_IMAGE_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_image_get_type (), GtkImageClass)
-#define GTK_IS_IMAGE(obj) GTK_CHECK_TYPE (obj, gtk_image_get_type ())
+#define GTK_TYPE_IMAGE (gtk_image_get_type ())
+#define GTK_IMAGE(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_IMAGE, GtkImage))
+#define GTK_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_IMAGE, GtkImageClass))
+#define GTK_IS_IMAGE(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_IMAGE))
+#define GTK_IS_IMAGE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IMAGE))
typedef struct _GtkImage GtkImage;
};
-guint gtk_image_get_type (void);
+GtkType gtk_image_get_type (void);
GtkWidget* gtk_image_new (GdkImage *val,
GdkBitmap *mask);
void gtk_image_set (GtkImage *image,
return NULL;
}
-guint
+GtkType
gtk_input_dialog_get_type (void)
{
- static guint input_dialog_type = 0;
+ static GtkType input_dialog_type = 0;
if (!input_dialog_type)
{
(GtkClassInitFunc) NULL,
};
- input_dialog_type = gtk_type_unique (gtk_dialog_get_type (),
+ input_dialog_type = gtk_type_unique (GTK_TYPE_DIALOG,
&input_dialog_info);
}
object_class = (GtkObjectClass*) klass;
- parent_class = gtk_type_class (gtk_dialog_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_DIALOG);
input_dialog_signals[ENABLE_DEVICE] =
gtk_signal_new ("enable_device",
{
GtkInputDialog *inputd;
- inputd = gtk_type_new (gtk_input_dialog_get_type ());
+ inputd = gtk_type_new (GTK_TYPE_INPUT_DIALOG);
return GTK_WIDGET (inputd);
}
#endif /* __cplusplus */
-#define GTK_INPUT_DIALOG(obj) GTK_CHECK_CAST (obj, gtk_input_dialog_get_type (), GtkInputDialog)
-#define GTK_INPUT_DIALOG_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_input_dialog_get_type (), GtkInputDialogClass)
-#define GTK_IS_INPUT_DIALOG(obj) GTK_CHECK_TYPE (obj, gtk_input_dialog_get_type ())
+#define GTK_TYPE_INPUT_DIALOG (gtk_input_dialog_get_type ())
+#define GTK_INPUT_DIALOG(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_INPUT_DIALOG, GtkInputDialog))
+#define GTK_INPUT_DIALOG_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_INPUT_DIALOG, GtkInputDialogClass))
+#define GTK_IS_INPUT_DIALOG(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_INPUT_DIALOG))
+#define GTK_IS_INPUT_DIALOG_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_INPUT_DIALOG))
typedef struct _GtkInputDialog GtkInputDialog;
};
-guint gtk_input_dialog_get_type (void);
+GtkType gtk_input_dialog_get_type (void);
GtkWidget* gtk_input_dialog_new (void);
(GtkClassInitFunc) NULL,
};
- invisible_type = gtk_type_unique (gtk_widget_get_type (), &invisible_info);
+ invisible_type = gtk_type_unique (GTK_TYPE_WIDGET, &invisible_info);
}
return invisible_type;
GtkWidget*
gtk_invisible_new (void)
{
- return GTK_WIDGET ( gtk_type_new (gtk_invisible_get_type ()));
+ return GTK_WIDGET (gtk_type_new (GTK_TYPE_INVISIBLE));
}
static void
{
GtkLayout *layout;
- layout = gtk_type_new (gtk_layout_get_type());
+ layout = gtk_type_new (GTK_TYPE_LAYOUT);
gtk_layout_set_adjustments (layout, hadjustment, vadjustment);
g_return_if_fail (layout != NULL);
g_return_if_fail (GTK_IS_LAYOUT (layout));
- layout->frozen = TRUE;
+ layout->freeze_count++;
}
void
g_return_if_fail (layout != NULL);
g_return_if_fail (GTK_IS_LAYOUT (layout));
- if (!layout->frozen)
- return;
-
- layout->frozen = FALSE;
- gtk_layout_position_children (layout);
- gtk_widget_draw (GTK_WIDGET (layout), NULL);
+ if (layout->freeze_count)
+ if (!(--layout->freeze_count))
+ {
+ gtk_layout_position_children (layout);
+ gtk_widget_draw (GTK_WIDGET (layout), NULL);
+ }
}
/* Basic Object handling procedures
*/
-guint
+GtkType
gtk_layout_get_type (void)
{
- static guint layout_type = 0;
+ static GtkType layout_type = 0;
if (!layout_type)
{
(GtkArgGetFunc) NULL,
};
- layout_type = gtk_type_unique (gtk_container_get_type (), &layout_info);
+ layout_type = gtk_type_unique (GTK_TYPE_CONTAINER, &layout_info);
}
return layout_type;
widget_class = (GtkWidgetClass*) class;
container_class = (GtkContainerClass*) class;
- parent_class = gtk_type_class (gtk_container_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
widget_class->realize = gtk_layout_realize;
widget_class->unrealize = gtk_layout_unrealize;
layout->scroll_x = 0;
layout->scroll_y = 0;
layout->visibility = GDK_VISIBILITY_PARTIAL;
+
+ layout->freeze_count = 0;
}
/* Widget methods
layout->xoffset = (gint)layout->hadjustment->value;
layout->yoffset = (gint)layout->vadjustment->value;
- if (layout->frozen)
+ if (layout->freeze_count)
return;
if (!GTK_WIDGET_MAPPED (layout))
extern "C" {
#endif /* __cplusplus */
-#define GTK_LAYOUT(obj) GTK_CHECK_CAST (obj, gtk_layout_get_type (), GtkLayout)
-#define GTK_LAYOUT_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_layout_get_type (), GtkLayoutClass)
-#define GTK_IS_LAYOUT(obj) GTK_CHECK_TYPE (obj, gtk_layout_get_type ())
+#define GTK_TYPE_LAYOUT (gtk_layout_get_type ())
+#define GTK_LAYOUT(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_LAYOUT, GtkLayout))
+#define GTK_LAYOUT_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_LAYOUT, GtkLayoutClass))
+#define GTK_IS_LAYOUT(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_LAYOUT))
+#define GTK_IS_LAYOUT_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LAYOUT))
typedef struct _GtkLayout GtkLayout;
typedef struct _GtkLayoutClass GtkLayoutClass;
gint scroll_x;
gint scroll_y;
- guint frozen : 1;
+ guint freeze_count;
};
struct _GtkLayoutClass {
GtkAdjustment *vadjustment);
};
+GtkType gtk_layout_get_type (void);
GtkWidget* gtk_layout_new (GtkAdjustment *hadjustment,
GtkAdjustment *vadjustment);
-
-guint gtk_layout_get_type (void);
void gtk_layout_put (GtkLayout *layout,
GtkWidget *widget,
gint x,
}
gchar*
-gtk_rc_find_module_in_path (GScanner *scanner,
+gtk_rc_find_module_in_path (GScanner *scanner,
const gchar *module_file)
{
gint i;
extern "C" {
#endif /* __cplusplus */
+
typedef enum {
GTK_RC_FG = 1 << 0,
GTK_RC_BG = 1 << 1,
struct _GtkRcStyle
{
- char *name;
- char *font_name;
- char *fontset_name;
- char *bg_pixmap_name[5];
+ gchar *name;
+ gchar *font_name;
+ gchar *fontset_name;
+ gchar *bg_pixmap_name[5];
GtkRcFlags color_flags[5];
GdkColor fg[5];
void gtk_rc_add_class_style (GtkRcStyle *rc_style,
const gchar *pattern);
-GtkRcStyle *gtk_rc_style_new (void);
+GtkRcStyle* gtk_rc_style_new (void);
void gtk_rc_style_ref (GtkRcStyle *rc_style);
void gtk_rc_style_unref (GtkRcStyle *rc_style);
/* Tell gtkrc to use a custom routine to load images specified in rc files instead of
* the default xpm-only loader
*/
-typedef GdkPixmap * (*GtkImageLoader) (GdkWindow *window,
- GdkColormap *colormap,
- GdkBitmap **mask,
- GdkColor *transparent_color,
- const gchar *filename);
-void gtk_rc_set_image_loader(GtkImageLoader loader);
-
-GdkPixmap *gtk_rc_load_image (GdkColormap *colormap,
- GdkColor *transparent_color,
- const gchar *filename);
-gchar *gtk_rc_find_pixmap_in_path (GScanner *scanner,
- const gchar *pixmap_file);
-gchar *gtk_rc_find_module_in_path (GScanner *scanner,
- const gchar *module_file);
-gchar *gtk_rc_get_theme_dir(void);
-gchar *gtk_rc_get_module_dir(void);
+typedef GdkPixmap* (*GtkImageLoader) (GdkWindow *window,
+ GdkColormap *colormap,
+ GdkBitmap **mask,
+ GdkColor *transparent_color,
+ const gchar *filename);
+void gtk_rc_set_image_loader (GtkImageLoader loader);
+
+GdkPixmap* gtk_rc_load_image (GdkColormap *colormap,
+ GdkColor *transparent_color,
+ const gchar *filename);
+gchar* gtk_rc_find_pixmap_in_path (GScanner *scanner,
+ const gchar *pixmap_file);
+gchar* gtk_rc_find_module_in_path (GScanner *scanner,
+ const gchar *module_file);
+gchar* gtk_rc_get_theme_dir (void);
+gchar* gtk_rc_get_module_dir (void);
/* private functions/definitions */
typedef enum {
if (socket->plug_window && socket->plug_window->user_data)
{
- GtkWidget *child_widget = GTK_WIDGET (socket->plug_window->user_data);
+ /*
+ GtkWidget *child_widget;
+
+ child_widget = GTK_WIDGET (socket->plug_window->user_data);
+ */
g_warning("Stealing from same app not yet implemented");
text->text = g_new (guchar, INITIAL_BUFFER_SIZE);
text->text_len = INITIAL_BUFFER_SIZE;
+
+ text->freeze_count = 0;
if (!params_mem_chunk)
params_mem_chunk = g_mem_chunk_new ("LineParams",
g_return_if_fail (text != NULL);
g_return_if_fail (GTK_IS_TEXT (text));
- text->freeze = TRUE;
+ text->freeze_count++;
}
void
g_return_if_fail (text != NULL);
g_return_if_fail (GTK_IS_TEXT (text));
- text->freeze = FALSE;
-
- if (GTK_WIDGET_REALIZED (text))
- {
- recompute_geometry (text);
- gtk_widget_queue_draw (GTK_WIDGET (text));
- }
+ if (text->freeze_count)
+ if (!(--text->freeze_count) && GTK_WIDGET_REALIZED (text))
+ {
+ recompute_geometry (text);
+ gtk_widget_queue_draw (GTK_WIDGET (text));
+ }
}
void
if (length == 0)
return;
- if (!text->freeze && (length > FREEZE_LENGTH))
+ if (!text->freeze_count && (length > FREEZE_LENGTH))
{
gtk_text_freeze (text);
frozen = TRUE;
}
- if (!text->freeze && (text->line_start_cache != NULL))
+ if (!text->freeze_count && (text->line_start_cache != NULL))
{
find_line_containing_point (text, text->point.index, TRUE);
old_height = total_line_height (text, text->current_line, 1);
advance_mark_n (&text->point, length);
- if (!text->freeze && (text->line_start_cache != NULL))
+ if (!text->freeze_count && text->line_start_cache != NULL)
insert_expose (text, old_height, length, new_line_count);
if (frozen)
if (text->point.index + nchars > TEXT_LENGTH (text) || nchars <= 0)
return FALSE;
- if (!text->freeze && (nchars > FREEZE_LENGTH))
+ if (!text->freeze_count && nchars > FREEZE_LENGTH)
{
gtk_text_freeze (text);
frozen = TRUE;
}
- if (!text->freeze && (text->line_start_cache != NULL))
+ if (!text->freeze_count && text->line_start_cache != NULL)
{
/* We need to undraw the cursor here, since we may later
* delete the cursor's property
delete_text_property (text, nchars);
- if (!text->freeze && (text->line_start_cache != NULL))
+ if (!text->freeze_count && (text->line_start_cache != NULL))
{
delete_expose (text, nchars, old_lines, old_height);
draw_cursor (text, FALSE);
/* True iff this buffer is wrapping lines, otherwise it is using a
* horizontal scrollbar. */
guint line_wrap : 1;
- /* Frozen, don't do updates. @@@ fixme */
- guint freeze : 1;
guint word_wrap : 1;
+ /* Frozen, don't do updates. @@@ fixme */
+ guint freeze_count;
/* TEXT PROPERTIES */
/* A doubly-linked-list containing TextProperty objects. */
}
void
-gtk_widget_freeze_accelerators (GtkWidget *widget)
+gtk_widget_lock_accelerators (GtkWidget *widget)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
}
void
-gtk_widget_thaw_accelerators (GtkWidget *widget)
+gtk_widget_unlock_accelerators (GtkWidget *widget)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
}
}
+void
+gtk_widget_thaw_accelerators (GtkWidget *widget)
+{
+ g_message ("gtk_widget_thaw_accelerators() is deprecated");
+
+ gtk_widget_unlock_accelerators (widget);
+}
+
+void
+gtk_widget_freeze_accelerators (GtkWidget *widget)
+{
+ g_message ("gtk_widget_freeze_accelerators() is deprecated");
+
+ gtk_widget_lock_accelerators (widget);
+}
+
void
gtk_widget_add_accelerator (GtkWidget *widget,
const gchar *accel_signal,
GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods);
-void gtk_widget_freeze_accelerators (GtkWidget *widget);
-void gtk_widget_thaw_accelerators (GtkWidget *widget);
+void gtk_widget_lock_accelerators (GtkWidget *widget);
+void gtk_widget_unlock_accelerators (GtkWidget *widget);
gint gtk_widget_event (GtkWidget *widget,
GdkEvent *event);
#endif /* GTK_TRACE_OBJECTS && __GNUC__ */
+/* deprecated */
+void gtk_widget_freeze_accelerators (GtkWidget *widget);
+void gtk_widget_thaw_accelerators (GtkWidget *widget);
+
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
projects / gtk4.git / commitdiff